package com.ohuang.util_a.task.rxtask;


import com.ohuang.util_a.task.OnceTaskCallBack;
import com.ohuang.util_a.task.Task;
import com.ohuang.util_a.task.TaskCallBack;

/**
 * 类似于rxjava 用于链式执行异步任务。
 * 通过map添加下一个任务,RxTask.<T>map()  通过泛型设置任务完成的返回的类型
 * 任务完成通过回调RXTaskCallBack.onSuccess(T t)或RXTaskCallBack.onFair();
 * @param <R>
 */
public class RxTask<R> extends Task {

    private RxTaskObserver<R, Object> child;
    RXTaskCallBack<R> mCallBack;
    private final RxTaskFirstRunnable<R> rRxTaskRunnable;

    RXTaskCallBack<Object>  mReturnCallBack;

    public RxTask(RxTaskFirstRunnable<R> rRxTaskRunnable) {
        this.rRxTaskRunnable = rRxTaskRunnable;
    }

    @Override
    public void run(TaskCallBack taskCallBack) {
        OnceTaskCallBack onceTaskCallBack=new OnceTaskCallBack() {
            @Override
            public void onCall() {
                taskCallBack.onNext();
            }
        };

        rRxTaskRunnable.run(new RXTaskCallBack<R>() {
            @Override
            public void onSuccess(R r) {
                if (mCallBack != null) {
                    mCallBack.onSuccess(r);
                }
                if (child != null) {
                    if (isStop()){ //停止直接结束
                        onceTaskCallBack.onNext();
                        return;
                    }
                    child.run(r, new RXTaskCallBack<Object>() {
                        @Override
                        public void onSuccess(Object o) {
                            onceTaskCallBack.onNext();
                            if (mReturnCallBack!=null){
                                mReturnCallBack.onSuccess(o);
                            }
                        }

                        @Override
                        public void onFair() {
                            onceTaskCallBack.onNext();
                            if (mReturnCallBack!=null){
                                mReturnCallBack.onFair();
                            }
                        }
                    });
                } else {
                    onceTaskCallBack.onNext();
                    if (mReturnCallBack!=null){
                        mReturnCallBack.onSuccess(r);
                    }
                }
            }

            @Override
            public void onFair() {
                if (mCallBack != null) {
                    mCallBack.onFair();
                }
                onceTaskCallBack.onNext();
                if (mReturnCallBack!=null){
                    mReturnCallBack.onFair();
                }
            }
        });
    }

    /**
     * 设置第一个任务回调
     * @param mCallBack
     * @return
     */
    public RxTask<R> setmCallBack(RXTaskCallBack<R> mCallBack) {
        this.mCallBack = mCallBack;
        return this;
    }

    /**
     * 设置所有任务结束回调
     * @param mReturnCallBack
     */
    public void setmReturnCallBack(RXTaskCallBack<Object> mReturnCallBack) {
        this.mReturnCallBack = mReturnCallBack;
    }

    public <U> RxTaskObserver<R, U> map(RxTaskRunnable<R, U> ruRxTaskRunnable) {
        RxTaskObserver<R, U> ruRxTaskObserver = new RxTaskObserver<>(this, new RxMapTask<>(ruRxTaskRunnable,this));
        child = (RxTaskObserver<R, Object>) ruRxTaskObserver;
        return ruRxTaskObserver;
    }

    /**
     *
     * @param timeOut  单次任务超时时间  默认0为不设置超时时间
     * @param maxCount  失败重新执行 ，最大次数  默认次数1
     * @param ruRxTaskRunnable
     * @return
     * @param <U>
     */
    public <U> RxTaskObserver<R, U> map(long timeOut, int maxCount, RxTaskRunnable<R, U> ruRxTaskRunnable) {
        RxTaskObserver<R, U> ruRxTaskObserver = new RxTaskObserver<>(this, new RxMapTask<>(timeOut,maxCount,ruRxTaskRunnable,this));
        child = (RxTaskObserver<R, Object>) ruRxTaskObserver;
        return ruRxTaskObserver;
    }

    public interface RxTaskFirstRunnable<R> {
        void run(RXTaskCallBack<R> taskCallBack);
    }
}
